import java.util.*;

public class StreamOperator {
    private static List<String> books = new ArrayList<>();

    static {
        books.add("Java从入门到精通");
        books.add("Java核心编程");
        books.add("数据结构与算法");
        books.add("C++项目实战");
        books.add("算法导论");
        books.add("微服务实现原理");
        books.add("基于Hadoop的日志分析");
    }

    /**
     * filter：过滤掉不符合断言判断的数据
     */
    public static void filterTest() {
        books.stream()
                .filter(ele -> ele.contains("Java"))
                .forEach(System.out::println);
    }

    /**
     * map: 将一个元素转换成另一个元素
     */
    public static void mapTest() {
        books.stream()
                .map(String::length)
                .forEach(System.out::println);
    }

    /**
     * flatMap: 将一个对象转换成流
     */
    public static void flatMapTest() {
        books.stream()
                .filter(ele -> ele.contains("Java"))
                .flatMap(ele -> Arrays.stream(ele.split("")))
                .forEach(System.out::println);
    }

    /**
     * peek: 遍历
     */
    public static void peekTest() {
        books.stream()
                .peek(ele -> System.out.println("peek value: " + ele))
                .forEach(System.out::println);
    }

    /**
     * sorted: 排序
     */
    public static void sortTest() {
        books.stream()
                .sorted(Comparator.comparing(String::length))
                .forEach(System.out::println);
    }

    /**
     * distinct: 去重
     */
    public static void distinctTest() {
        books.stream()
                .mapToInt(String::length)
                .distinct()
                .forEach(System.out::println);
    }

    /**
     * skip: 跳过
     */
    public static void skipTest() {
        books.stream()
                .sorted(Comparator.comparing(String::length))
                .skip(3)
                .forEach(System.out::println);
    }

    /**
     * limit: 截断
     */
    public static void limitTest() {
        books.stream()
                .sorted(Comparator.comparing(String::length))
                .skip(3)
                .limit(2)
                .forEach(System.out::println);
    }

    /**
     * allMatch：终端操作，短路操作（遇到不符合条件的就会终止，返回false，后面的元素不会再遍历）
     */
    public static void allMatchTest() {
        boolean result = books.stream()
                .peek(System.out::println)
                .allMatch(ele -> ele.length() > 9);
        System.out.println(result);
    }

    /**
     * anyMatch: 短路操作（遇到符合条件的就会终止，返回true，后面的元素不会再遍历）
     */
    public static void anyMatchTest() {
        boolean result = books.stream()
                .peek(System.out::println)
                .anyMatch(ele -> ele.length() > 9);
        System.out.println(result);
    }

    /**
     * noneMatch：终端操作，短路操作（遇到符合条件的就会终止，返回false，后面的元素不会再遍历）
     */
    public static void noneMatchTest() {
        boolean result = books.stream()
                .peek(System.out::println)
                .noneMatch(ele -> ele.length() > 9);
        System.out.println(result);
    }

    /**
     * findFirst: 取第一个
     */
    public static void findFirstTest() {
        Optional<String> result = books.stream()
                .findFirst();
        System.out.println(result.get());
    }

    /**
     * findAny: 返回的元素不确定（如果是数据较少，串行地情况下，一般会返回第一个结果，如果是并行的情况，那就不能确保是第一个）
     */
    public static void findAnyTest() {
        Optional<String> result = books.stream()
                .findAny();
        System.out.println(result.get());
    }

    /**
     * max：求最大
     */
    public static void maxTest() {
        OptionalInt result = books.stream()
                // 将String类型转为Int类型
                .mapToInt(String::length)
                .max();
        System.out.println(result.getAsInt());
    }

    /**
     * min：求最小
     */
    public static void minTest() {
        OptionalInt result = books.stream()
                // 将String类型转为Int类型
                .mapToInt(String::length)
                .min();
        System.out.println(result.getAsInt());
    }

    /**
     * count：求个数
     */
    public static void countTest() {
        long result = books.stream()
                .count();
        System.out.println(result);
    }

    public static void main(String[] args) {
        filterTest();
        mapTest();
        flatMapTest();
        peekTest();
        sortTest();
        distinctTest();
        skipTest();
        limitTest();
        allMatchTest();
        anyMatchTest();
        noneMatchTest();
        findFirstTest();
        findAnyTest();
        maxTest();
        minTest();
        countTest();
    }
}
